<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
          //1. 写一个函数，能返回传入的任意两个数字的最大值。
           var num1 = +prompt('请输入数字')
           var num2 = +prompt('请输入数字')
           // 命名函数，在预解析时会进行函数提升，所以可以在声明函数之前调用函数
           console.log(maxValue(num1, num2)); 
           function maxValue(num1, num2) {
               if(parseInt(num1) && parseInt(num2)) {
                   return num1 > num2 ? num1 : num2;
               } else {
                   alert('请输入数字')
               }
           //return parseInt(num1) && parseInt(num2) ? num1 > num2 ? num1 : num2 : alert('请输入数字')
           }  
       
        


           //2. 写一个函数，能返回传入的任意三个数字的最大值。
              var num3 = +prompt('请输入数字')
              var num4 = +prompt('请输入数字')
              var num5 = +prompt('请输入数字')
              //  命名函数，在预解析时会进行函数提升，所以可以在声明函数之前调用函数
              console.log(maxValue(num3, num4, num5)); 
              function maxValue(num3, num4, num5) {
                  if(parseInt(num3) && parseInt(num4) && parseInt(num5)) {
                      //前两个值先比较，返回大的那个值，再和第三个数进行比较，在返回比较后大的那个值
                      return (num3 > num4 ? num3 : num4) > num5 ? (num3 > num4 ? num3 : num4) : num5;
                  } else {
                      alert('请输入数字')
                  }
              } 
       

        /*   3. 写一个函数，能判断传入的一个数值是否是质数，如果是质数返回true，
                如果不是质数返回false，(质数：从2开始只能被1和自身整除的数但不能被其他数整除) */
        var prime = +prompt('请输入一个数字')
        //设置标记数
        var num = 0
        function judge(prime) {
           for(var i = 1; i <= prime; i++) {
               //让输入的数 与 1 ~ 它本身 之间的所有数模运算
               //可以整除的个数使用标记数进行记录
               if(prime % i == 0) {
                   num++
               }
           }
           //因为质数只能被1和它本身整除，所以标记数为2 的就为质数
           if(num == 2) {
                  return alert('这是一个质数')                   
               } else {
                  return alert('这不是一个质数')                  
               }
        }
        judge(prime);



        //4. 写一个函数，能翻转传入的任意数组，并把翻转结果通过返回值返回。
        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        var temp;
        //如果是奇数个，那么中间那个就不用交换
        //如果是偶数个，那么就一半换一半
        //使用取整获得交换次数
        var len = Math.floor(arr.length / 2)
        // console.log(reverse(arr));
        function reverse(arr) {
            for (var i = 0; i < len; i++) {
                temp = arr[i]
                //i 代表前一半数据，[arr.length - i - 1]代表后一半数据， 两者进行交换
                arr[i] = arr[arr.length - i - 1]
                arr[arr.length - i - 1] = temp
            }
            return arr
        }

        //5. 写一个函数，能对所有传入的数组按照从小到大进行排序，并把排序结果通过返回值返回
        var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1]
        var temp
        function sort(arr) {
            for(var i = 0; i < arr.length - 1; i++) {
                // 设置一个标记
                var key = true
                for(var j = 0; j < arr.length - 1 - i; j++) {
                    if(arr[j] > arr[j + 1]) {
                        temp = arr[j]
                        arr[j] = arr[j + 1]
                        arr[j + 1] = temp
                        //如果数组已经为有序的，那么就不会进入判断，那么key 始终为true
                        key = false
                    }
                }
                //在数组已经为有序的情况下，直接break 退出大循环
                if(key){
                    break
                }
            }
            return arr
        }
        console.log(sort(arr));
    </script>
</head>

<body>

</body>

</html>